(DEFINEQ (RAND-REMUTE (LAMBDA (L L1) (CONS (SETQ L1 (RAND-MEMB
L))(RAND-PERMUTE
(DREMOVE L1 L]
EDIT

*2 P
(RAND-REMUTE (LAMBDA & &))
*(1 RAND-PERMUTE)

*OK
(RAND-PERMUTE)
:RAND-PERMUTE((1 2 3 4 5 6 7 8 9))

GC: 18
2214, 3238 FREE WORDS

STACK OVERFLOW IN GC - COMPUTATION LOST

←
PP(RAND-PERMUTE)

(RAND-PERMUTE
  [LAMBDA (L L1)
    (CONS (SETQ L1 (RAND-MEMB L))
          (RAND-PERMUTE (DREMOVE L1 L])
(RAND-PERMUTE)
←
SET(LL (1 2 3 4))
(1 2 3 4)
←
(SETQ L1 (RAND-MEMB LL))
3
←
EDITF(RAND-PERMUTE)
EDIT

*P
(LAMBDA (L L1) (CONS & &))
*3
*MBD AND L
*OK
RAND-PERMUTE
←RAND-PERMUTE((3))
(3)
←
RAND-PERMUTE((3 4 5 6 7))
(4 3 6 7 5)
←
PP(RAND-PERMUTE)

(RAND-PERMUTE
  [LAMBDA (L L1)
    (AND L (CONS (SETQ L1 (RAND-MEMB L))
                 (RAND-PERMUTE (DREMOVE L1 L])
(RAND-PERMUTE)
←
(DEFINEQ (RAND-PERMUTE (LAMBDA (L M) (MAPC (L) (FUNCTION
(LAMBDA (L1) (ATTACH L1 (FNTH M (RAND 1 (LENGTH M)]
EDIT

*2 (1 RP)

*P
(RP (LAMBDA & &))
*-1 P
(LAMBDA (L M) (MAPC & &))
*(-3 (SETQ M (LIST T]

*4 P
(MAPC (L) (FUNCTION &))
*BO 2
*-1 -1 P
(LAMBDA (L1) (ATTACH L1 &))
*0 0 P
(MAPC L (FUNCTION &))
*0 P
(LAMBDA (L M) (SETQ M &) (MAPC L &))
*(N (CDR (DREVERSE M]

*OK
(RP)
←RP((2 3))
(3 2)
←
(TIME (RP '(1 2 3 4 5 6 7 8 9]
19 CONSES
.471 SECONDS
(6 3 1 7 9 5 8 4 2)
←
(TIME (RAND-PERMUTE '(1 2 3 4 5 6 7 8 9]
18 CONSES
.225 SECONDS
(5 4 7 6 2 8 9 3 1)
←
EDITF(PSUF)
EDIT

*P
(LAMBDA (P B BA1 BA2 BA3 BA4 RS C1) (INIT-PART B P) (AND & & & &))
*(3)

*3 P
(AND (SETQ C1 &) (SETQ RS &) (PROG1 T &) (NCONCB B P &))
*4 P
(PROG1 T (AND BA1 & & & & &))
*(1 OR)

*(2)

*(N (INIT-PART B P))

*P
(OR (AND BA1 & & & & &) (INIT-PART B P))
*2 P
(AND BA1 (FMEMB P STRATEGY-PARTS) (FMEMB BA1 FACETS) (SETQ RS &) (NCONC 
**RS &) (SETQ RS &))
*(-5 (INIT-PART B BA1]

*6
*UP
*LI 1
*P
... (& & &))
*1 P
((SETQ RS &) (NCONC RS &) (SETQ RS &))
*BO 1
*UNDO
BO UNDONE.
*LO 1
*P
(SETQ RS (MAPCONC RS &))
*0 P
... (SETQ RS &))
*0 P
(AND BA1 (FMEMB P STRATEGY-PARTS) (FMEMB BA1 FACETS) (INIT-PART B BA1) (
**SETQ RS &))
*UNDO FROM LI
LI UNDONE.
ALREADY UNDONE.
UNDO UNDONE.
LO UNDONE.
*P
((SETQ RS & & &) (NCONC RS &) (SETQ RS &))
*0 P
... (SETQ RS & & &) (NCONC RS &) (SETQ RS &))
*0 P
(AND BA1 (FMEMB P STRATEGY-PARTS) (FMEMB BA1 FACETS) (INIT-PART B BA1) (
**SETQ RS & & &) (NCONC RS &) (SETQ RS &))
*PP
  (AND BA1 (FMEMB P STRATEGY-PARTS)
       (FMEMB BA1 FACETS)
       (INIT-PART B BA1)
       (SETQ RS [MAPCONC RS (FUNCTION (LAMBDA (R)
                             (IS-CON-L (GLUE R BA1]
         [NCONC RS (MAPCONC RS (FUNCTION (LAMBDA (R)
                                (RIPPLE-SIMULT R C1]
         (SETQ RS (INTERSECTION RS RS)))
       [NCONC RS (MAPCONC RS (FUNCTION (LAMBDA (R)
                              (RIPPLE-SIMULT R C1]
       (SETQ RS (INTERSECTION RS RS)))
*6 P
(SETQ RS (MAPCONC RS &) (NCONC RS &) (SETQ RS &))
*(4)

*(4)

*0 P
(AND BA1 (FMEMB P STRATEGY-PARTS) (FMEMB BA1 FACETS) (INIT-PART B BA1) (
**SETQ RS &) (NCONC RS &) (SETQ RS &))
*OK
PSUF
←EDITP(OSET-STRUC)
EDIT

*P
(GENL (STRUCTURE) WORTH (300 200 700 500 400 990 900 1000 800 800 1000) 
**DEFN (ANY1OF & &) INTU (ANY1OF &) OPS (
OSET-STRUC-DELETE OSET-STRUC-EQUAL) FILLIN (ANY-OF NIL & & &))
*-2 UP PP
  (FILLIN (ANY-OF NIL (OSET DOUG (VECTOR (CLASS DOUG)))
                  (OSET)
                  (COPY (APPLYB (QUOTE STRUCTURE-MEMB)
                                (QUOTE ALGS)
                                NIL
                                (COPY BA1))
                        BA1)))
*(1)

*(:)

*GEXISTING


GEXISTING  ?
*OK
OSET-STRUC
←EDITP(SET-STRUC)
EDIT

*P
(GENL (STRUCTURE) WORTH (800 800 700 500 400 990 900 1000 800 800 1000) 
**DEFN (ANY1OF & &) INTU (ANY1OF & &) OPS (
SET-STRUC-DELETE SET-STRUC-EQUAL) CHECK (ANY-OF NIL))
*-3 UP
*(2)

*(2)

*OK
SET-STRUC
←GEXISTING
(ANY-OF NIL (OSET DOUG (VECTOR (CLASS DOUG))) (OSET) (COPY (APPLYB (QUOT
**E STRUCTURE-MEMB) (QUOTE ALGS) NIL (COPY BA1))
BA1))
←SET(GEXISTING (CLASS SPECIAL CLASS JUST FOR THIS]
(GEXISTING RESET)
(CLASS SPECIAL CLASS JUST FOR THIS)
←
SET(GEXISTING ((CLASS SPECIAL CLASS JUST FOR THIS]
(GEXISTING RESET)
((CLASS SPECIAL CLASS JUST FOR THIS))
←
SET-STRUC-DELETE(INV (APPLYB 'STRUCTURE-MEMB 'ALGS NIL BA1) BA1)
(CLASS SET-STRUC-DELETE SPECIAL CLASS JUST FOR THIS)
←
MAPC((SET-STRUC-DELETE-E-INV PGET STRUCTURE-MEMB STRUCTURE-INSERT) TRACE
**)
NIL
←
REDO -2

SET-STRUC-DELETE-E-INV:
BA1 = (APPLYB 'STRUCTURE-MEMB 'ALGS NIL BA1)
BA2 = BA1
BA3 = NIL
BA4 = NIL

   PGET:
   P = EXS
   B = OBJECT
   PGET = ((VECTOR) (VECTOR (CLASS DOUG)) (VECTOR DOUG ED BRUCE))

   PGET:
   P = EXS
   B = OBJECT
   PGET = ((VECTOR) (VECTOR (CLASS DOUG)) (VECTOR DOUG ED BRUCE))

   STRUCTURE-MEMB:
   BP = INV
   BA1 = NIL
   BA2 = (CLASS SPECIAL CLASS JUST FOR THIS)
   BA3 = NIL
   BA4 = NIL

      PGET:
      P = EXS
      B = OBJECT
      PGET = ((VECTOR) (VECTOR (CLASS DOUG)) (VECTOR DOUG ED BRUCE))
   STRUCTURE-MEMB = DOUG

   STRUCTURE-INSERT:
   BP = ALGS
   BA1 = DOUG
   BA2 = (CLASS SPECIAL CLASS JUST FOR THIS)
   BA3 = NIL
   BA4 = NIL
   STRUCTURE-INSERT = (CLASS DOUG SPECIAL CLASS JUST FOR THIS)
SET-STRUC-DELETE-E-INV = (CLASS DOUG SPECIAL CLASS JUST FOR THIS)
(CLASS DOUG SPECIAL CLASS JUST FOR THIS)
←FIX -3
EDIT
*P
(SET-STRUC-DELETE (INV & BA1))
*R BA1 (COPY BA1)
...
*OK

SET-STRUC-DELETE-E-INV:
BA1 = (APPLYB 'STRUCTURE-MEMB 'ALGS NIL (COPY BA1))
BA2 = (COPY BA1)
BA3 = NIL
BA4 = NIL

   PGET:
   P = EXS
   B = OBJECT
   PGET = ((VECTOR) (VECTOR (CLASS DOUG)) (VECTOR DOUG ED BRUCE))

   PGET:
   P = EXS
   B = OBJECT
   PGET = ((VECTOR) (VECTOR (CLASS DOUG)) (VECTOR DOUG ED BRUCE))

   STRUCTURE-MEMB:
   BP = INV
   BA1 = NIL
   BA2 = (CLASS SPECIAL CLASS JUST FOR THIS)
   BA3 = NIL
   BA4 = NIL

      PGET:
      P = EXS
      B = OBJECT
      PGET = ((VECTOR) (VECTOR (CLASS DOUG)) (VECTOR DOUG ED BRUCE))
   STRUCTURE-MEMB = BRUCE

   STRUCTURE-INSERT:
   BP = ALGS
   BA1 = BRUCE
   BA2 = (CLASS SPECIAL CLASS JUST FOR THIS)
   BA3 = NIL
   BA4 = NIL
   STRUCTURE-INSERT = (CLASS BRUCE SPECIAL CLASS JUST FOR THIS)
SET-STRUC-DELETE-E-INV = (CLASS BRUCE SPECIAL CLASS JUST FOR THIS)
(CLASS BRUCE SPECIAL CLASS JUST FOR THIS)
←EDITF(RAND-MEMB)
EDIT

*P
(LAMBDA (S) (AND & &))
*3 P
(AND (LISTP S) (CAR &))
*-1 -1 P
(FNTH S (RAND 1 &))
*E (RAND 2 1)
2

*0 P
(CAR (FNTH S &))
*0 0 P
(LAMBDA (S) (AND & &))
*(-3 (SETQ S (REMOVE NIL (REMOVE 'ANY1OF (REMOVE 'ANY-OF  S]

*P
(LAMBDA (S) (SETQ S &) (AND & &))
*OK
RAND-MEMB
←TRACE(RAND-MEMB)
(RAND-MEMB)
←
BREAK(SET-STRUC-DELETE)
(SET-STRUC-DELETE)
←
START)

ENTERING MAIN LOOP NOW.


VERBOSITY LEVEL  (0-10) ... 
10
 DO-THRESH REDUCED TO 1023
 MUST FIND NEW CANDS 

(SET-STRUC-DELETE BROKEN)
:OK
SET-STRUC-DELETE

STRUCTURE-INSERT:
BP = SUGG
BA1 = 204
BA2 = NIL
BA3 = NIL
BA4 = NIL
STRUCTURE-INSERT = NIL

STRUCTURE-MEMB:
BP = SUGG
BA1 = 204
BA2 = NIL
BA3 = NIL
BA4 = NIL
STRUCTURE-MEMB = NIL
 DO-THRESH REDUCED TO 682
 MUST FIND NEW CANDS 

(SET-STRUC-DELETE BROKEN)
:OK
SET-STRUC-DELETE

STRUCTURE-INSERT:
BP = SUGG
BA1 = 136
BA2 = NIL
BA3 = NIL
BA4 = NIL
STRUCTURE-INSERT = NIL

STRUCTURE-MEMB:
BP = SUGG
BA1 = 136
BA2 = NIL
BA3 = NIL
BA4 = NIL
STRUCTURE-MEMB = NIL
NEW CAND = (760 FILLIN SET-STRUC EXS)
PGET:
P = EXS
B = OBJECT
PGET = ((VECTOR) (VECTOR (CLASS DOUG)) (VECTOR DOUG ED BRUCE))

RAND-MEMB:
S = ((VECTOR) (VECTOR (CLASS DOUG)) (VECTOR DOUG ED BRUCE))
RAND-MEMB = (VECTOR DOUG ED BRUCE)

RAND-MEMB:
S = (ACTIVE ANYB ANYB-ANAS ANYB-ANYP ANYB-CHECK ANYB-D-R ANYB-DEFN ANYB-
**EXS ANYB-EXS-BDY ANYB-EXS-NOT ANYB-EXS-NOT-BDY
ANYB-FILLIN ANYB-GENL ANYB-INT ANYB-INT-NOT ANYB-INTU ANYB-INV ANYB-OPS 
**ANYB-RESTRUC ANYB-SPEC ANYB-SUGG ANYB-UP 
ANYB-WORTH BAG-STRUC BAG-STRUC-DELETE CONSTRUCTIVE LIST-STRUC LIST-STRUC
**-DELETE OBJECT OPERATION OSET-STRUC 
OSET-STRUC-DELETE PREDICATE RELATION SET-STRUC SET-STRUC-DELETE SET-STRU
**C-EQUAL STRUCTURE STRUCTURE-DELETE 
STRUCTURE-EQUAL STRUCTURE-EXS STRUCTURE-INSERT STRUCTURE-MEMB)
RAND-MEMB = ANYB

RAND-MEMB:
S = (AVRA BRUCE CORDELL DOUG ED)
RAND-MEMB = DOUG

RAND-MEMB:
S = ((VECTOR DOUG ED BRUCE) ANYB DOUG)
RAND-MEMB = DOUG

PGET:
P = EXS
B = OBJECT
PGET = ((VECTOR) (VECTOR (CLASS DOUG)) (VECTOR DOUG ED BRUCE))

RAND-MEMB:
S = ((VECTOR) (VECTOR (CLASS DOUG)) (VECTOR DOUG ED BRUCE))
RAND-MEMB = (VECTOR)

RAND-MEMB:
S = (ACTIVE ANYB ANYB-ANAS ANYB-ANYP ANYB-CHECK ANYB-D-R ANYB-DEFN ANYB-
**EXS ANYB-EXS-BDY ANYB-EXS-NOT ANYB-EXS-NOT-BDY
ANYB-FILLIN ANYB-GENL ANYB-INT ANYB-INT-NOT ANYB-INTU ANYB-INV ANYB-OPS 
**ANYB-RESTRUC ANYB-SPEC ANYB-SUGG ANYB-UP 
ANYB-WORTH BAG-STRUC BAG-STRUC-DELETE CONSTRUCTIVE LIST-STRUC LIST-STRUC
**-DELETE OBJECT OPERATION OSET-STRUC 
OSET-STRUC-DELETE PREDICATE RELATION SET-STRUC SET-STRUC-DELETE SET-STRU
**C-EQUAL STRUCTURE STRUCTURE-DELETE 
STRUCTURE-EQUAL STRUCTURE-EXS STRUCTURE-INSERT STRUCTURE-MEMB)
RAND-MEMB = ANYB-SPEC

RAND-MEMB:
S = (AVRA BRUCE CORDELL DOUG ED)
RAND-MEMB = ED

RAND-MEMB:
S = ((VECTOR) ANYB-SPEC ED)
RAND-MEMB = ANYB-SPEC

(SET-STRUC-DELETE BROKEN)
:?=
BP = INV
BA1 = (APPLYB (QUOTE STRUCTURE-MEMB) (QUOTE ALGS) NIL (COPY BA1))
BA2 = (COPY BA1)
BA3 = NIL
BA4 = NIL
:GEXISTING
(ANY-OF NIL (CLASS DOUG ANYB-SPEC))
:OK

   SET-STRUC-DELETE-E-INV:
   BA1 = (APPLYB (QUOTE STRUCTURE-MEMB) (QUOTE ALGS) NIL (COPY BA1))
   BA2 = (COPY BA1)
   BA3 = NIL
   BA4 = NIL

      RAND-MEMB:
      S = (ANY-OF NIL (CLASS DOUG ANYB-SPEC))
      RAND-MEMB = (CLASS DOUG ANYB-SPEC)

      PGET:
      P = EXS
      B = OBJECT
      PGET = ((VECTOR) (VECTOR (CLASS DOUG)) (VECTOR DOUG ED BRUCE))

      RAND-MEMB:
      S = ((VECTOR) (VECTOR (CLASS DOUG)) (VECTOR DOUG ED BRUCE))
      RAND-MEMB = (VECTOR)

      RAND-MEMB:
      S = (ACTIVE ANYB ANYB-ANAS ANYB-ANYP ANYB-CHECK ANYB-D-R ANYB-DEFN
** ANYB-EXS ANYB-EXS-BDY ANYB-EXS-NOT 
ANYB-EXS-NOT-BDY ANYB-FILLIN ANYB-GENL ANYB-INT ANYB-INT-NOT ANYB-INTU A
**NYB-INV ANYB-OPS ANYB-RESTRUC ANYB-SPEC 
ANYB-SUGG ANYB-UP ANYB-WORTH BAG-STRUC BAG-STRUC-DELETE CONSTRUCTIVE LIS
**T-STRUC LIST-STRUC-DELETE OBJECT OPERATION
OSET-STRUC OSET-STRUC-DELETE PREDICATE RELATION SET-STRUC SET-STRUC-DELE
**TE SET-STRUC-EQUAL STRUCTURE STRUCTURE-DELETE
STRUCTURE-EQUAL STRUCTURE-EXS STRUCTURE-INSERT STRUCTURE-MEMB)
      RAND-MEMB = SET-STRUC-EQUAL

      RAND-MEMB:
      S = (AVRA BRUCE CORDELL DOUG ED)
      RAND-MEMB = BRUCE

      RAND-MEMB:
      S = ((VECTOR) SET-STRUC-EQUAL BRUCE)
      RAND-MEMB = SET-STRUC-EQUAL

      PGET:
      P = EXS
      B = OBJECT
      PGET = ((VECTOR) (VECTOR (CLASS DOUG)) (VECTOR DOUG ED BRUCE))

      RAND-MEMB:
      S = ((VECTOR) (VECTOR (CLASS DOUG)) (VECTOR DOUG ED BRUCE))
      RAND-MEMB = (VECTOR (CLASS DOUG))

      RAND-MEMB:
      S = (ACTIVE ANYB ANYB-ANAS ANYB-ANYP ANYB-CHECK ANYB-D-R ANYB-DEFN
** ANYB-EXS ANYB-EXS-BDY ANYB-EXS-NOT 
ANYB-EXS-NOT-BDY ANYB-FILLIN ANYB-GENL ANYB-INT ANYB-INT-NOT ANYB-INTU A
**NYB-INV ANYB-OPS ANYB-RESTRUC ANYB-SPEC 
ANYB-SUGG ANYB-UP ANYB-WORTH BAG-STRUC BAG-STRUC-DELETE CONSTRUCTIVE LIS
**T-STRUC LIST-STRUC-DELETE OBJECT OPERATION
OSET-STRUC OSET-STRUC-DELETE PREDICATE RELATION SET-STRUC SET-STRUC-DELE
**TE SET-STRUC-EQUAL STRUCTURE STRUCTURE-DELETE
STRUCTURE-EQUAL STRUCTURE-EXS STRUCTURE-INSERT STRUCTURE-MEMB)
      RAND-MEMB = ANYB-EXS

      RAND-MEMB:
      S = (AVRA BRUCE CORDELL DOUG ED)
      RAND-MEMB = BRUCE

      RAND-MEMB:
      S = ((VECTOR (CLASS DOUG)) ANYB-EXS BRUCE)
      RAND-MEMB = ANYB-EXS

      STRUCTURE-MEMB:
      BP = INV
      BA1 = NIL
      BA2 = (CLASS DOUG ANYB-SPEC)
      BA3 = NIL
      BA4 = NIL

         PGET:
         P = EXS
         B = OBJECT
         PGET = ((VECTOR) (VECTOR (CLASS DOUG)) (VECTOR DOUG ED BRUCE))

         RAND-MEMB:
         S = ((VECTOR) (VECTOR (CLASS DOUG)) (VECTOR DOUG ED BRUCE))
         RAND-MEMB = (VECTOR DOUG ED BRUCE)

         RAND-MEMB:
         S = (ACTIVE ANYB ANYB-ANAS ANYB-ANYP ANYB-CHECK ANYB-D-R ANYB-D
**EFN ANYB-EXS ANYB-EXS-BDY ANYB-EXS-NOT 
ANYB-EXS-NOT-BDY ANYB-FILLIN ANYB-GENL ANYB-INT ANYB-INT-NOT ANYB-INTU A
**NYB-INV ANYB-OPS ANYB-RESTRUC ANYB-SPEC 
ANYB-SUGG ANYB-UP ANYB-WORTH BAG-STRUC BAG-STRUC-DELETE CONSTRUCTIVE LIS
**T-STRUC LIST-STRUC-DELETE OBJECT OPERATION
OSET-STRUC OSET-STRUC-DELETE PREDICATE RELATION SET-STRUC SET-STRUC-DELE
**TE SET-STRUC-EQUAL STRUCTURE STRUCTURE-DELETE
STRUCTURE-EQUAL STRUCTURE-EXS STRUCTURE-INSERT STRUCTURE-MEMB)
         RAND-MEMB = STRUCTURE-INSERT

         RAND-MEMB:
         S = (AVRA BRUCE CORDELL DOUG ED)
         RAND-MEMB = AVRA

         RAND-MEMB:
         S = ((VECTOR DOUG ED BRUCE) STRUCTURE-INSERT AVRA)
         RAND-MEMB = AVRA
      STRUCTURE-MEMB = AVRA

      STRUCTURE-INSERT:
      BP = ALGS
      BA1 = AVRA
      BA2 = (CLASS DOUG ANYB-SPEC)
      BA3 = NIL
      BA4 = NIL
      STRUCTURE-INSERT = (CLASS AVRA DOUG ANYB-SPEC)
   SET-STRUC-DELETE-E-INV = (CLASS AVRA DOUG ANYB-SPEC)
SET-STRUC-DELETE

PGET:
P = EXS
B = LIST-STRUC
PGET = ((VECTOR) (VECTOR (CLASS DOUG)) (VECTOR DOUG ED BRUCE))
VIEWING: RETURNS NIL FOR NOW VIEWING: RETURNS NIL FOR NOW VIEWING: RETUR
**NS NIL FOR NOW 
PGET:
P = EXS
B = BAG-STRUC
PGET = NIL

PGET:
P = EXS
B = OSET-STRUC
PGET = NIL
NEW CAND = (760 FILLIN SET-STRUC EXS)REPEATER CAND SKIPPED
 DO-THRESH REDUCED TO 480
NEW CAND = (570 CHECK SET-STRUC EXS) DO-THRESH REDUCED TO 350
 MUST FIND NEW CANDS 

(SET-STRUC-DELETE BROKEN)
:GEXISTING
(ANY-OF NIL (CLASS DOUG ANYB-SPEC) (CLASS) (CLASS AVRA DOUG ANYB-SPEC) (
**CLASS AVRA BRUCE ED) (CLASS R2-2 R2-3 R3-2
R3-3 R4-2 R4-3 R5-2 R5-3 R6-2 R6-3 R7-2 R7-3) NIL NIL NIL)
:?=
BP = SUGG
BA1 = 70
BA2 = NIL
BA3 = NIL
BA4 = NIL
:EDITP(SET-STRUC)
EDIT

*P
(GENL (STRUCTURE) WORTH (800 800 700 500 400 990 900 1000 800 800 1000) 
**DEFN (ANY1OF & &) INTU (ANY1OF & &) OPS (
SET-STRUC-DELETE SET-STRUC-EQUAL) EXS (ANY-OF NIL & & & & & NIL NIL NIL)
** FILLIN (& & & & & & & NIL NIL NIL))
*-4 UP LI 1 PP

(LI 1 PP)  ?
*LI 1
*PP
  ((EXS (ANY-OF NIL (CLASS DOUG ANYB-SPEC)
                (CLASS)
                (CLASS AVRA DOUG ANYB-SPEC)
                (CLASS AVRA BRUCE ED)
                (CLASS R2-2 R2-3 R3-2 R3-3 R4-2 R4-3 R5-2 R5-3 R6-2 R6-3
** R7-2 R7-3)
                NIL NIL NIL)
        FILLIN
        ((CLASS DOUG ANYB-SPEC)
         (CLASS)
         (CLASS AVRA DOUG ANYB-SPEC)
         (CLASS AVRA BRUCE ED)
         (CLASS R2-2 R2-3 R3-2 R3-3 R4-2 R4-3 R5-2 R5-3 R6-2 R6-3 R7-2 R
**7-3)
         (CLASS AVRA BRUCE ED)
         (CLASS R2-2 R2-3 R3-2 R3-3 R4-2 R4-3 R5-2 R5-3 R6-2 R6-3 R7-2 R
**7-3)
         NIL NIL NIL)))
*EDITF(PSUF)
=E EDITF
EDIT

*P
(LAMBDA (P B BA1 BA2 BA3 BA4 RS C1) (AND & & & &))
*2 (N PP)

*NX P
(AND (SETQ C1 &) (SETQ RS &) (OR & &) (NCONCB B P &))
*4 P
(OR (AND BA1 & & & & & &) (INIT-PART B P))
*(B (SETQ PP P))

*P
... (SETQ PP P) (OR & &) (NCONCB B P &))
*2 P
(OR (AND BA1 & & & & & &) (INIT-PART B P))
*(3 T)

*2 P
(AND BA1 (FMEMB P STRATEGY-PARTS) (FMEMB BA1 FACETS) (INIT-PART B BA1) (
**SETQ RS &) (NCONC RS &) (SETQ RS &))
*5 P
(INIT-PART B BA1)
*(:)

*0 P
(AND BA1 (FMEMB P STRATEGY-PARTS) (FMEMB BA1 FACETS) (SETQ RS &) (NCONC 
**RS &) (SETQ RS &))
*0 P
(OR (AND BA1 & & & & &) T)
*0 P
... (SETQ PP P) (OR & T) (NCONCB B P &))
*(-3 (INIT-PART B PP))

*4 P
(NCONCB B P (NCONC & & & &))
*(3 PP)

*OK
PSUF
*P
... (EXS & FILLIN &))
*(:)

*P
... (SET-STRUC-DELETE SET-STRUC-EQUAL))
*OK
SET-STRUC
:EDITP(OSET-STRUC)
EDIT

*P
(GENL (STRUCTURE) WORTH (300 200 700 500 400 990 900 1000 800 800 1000) 
**DEFN (ANY1OF & &) INTU (ANY1OF &) OPS (
OSET-STRUC-DELETE OSET-STRUC-EQUAL))
*OK
OSET-STRUC
:SYSOUT(S)